//#include<stdio.h>
//int main()
//{
//    int arr[10], i;
//    for (i = 0;i < 10;i++)
//    {
//        scanf("%d", (arr + i));
//        if (arr[i] <= 0)
//            arr[i] = 1;
//        printf("X[%d] = %d\n", i, arr[i]);//也放在第一次遍历
//    }
//    /*for (i = 0;i < 10;i++)
//    {
//        printf("X[%d] = %d\n", i, arr[i]);
//    }*/
//    return 0;
//}



//int main()
//{  //可以在这里初始化
//    for (int i = 0; i < 100; i++)
//    {
//
//    }
//}



//int main()
//{
//	int arr[2][3] = { {1,2,3},{4,5,6} };
//	printf("%d\n", *(*(arr + 1) + 1));
//	//(arr+1)还正常，就是解引用时*(arr + 1)变成是地址
//	//就是解引用时本来解出的是在该地址里放的内容(该元素数组的内容)解成了地址(该元素数组的首元素的地址)
//	return 0;
//}


//AC 743.数组的行 -- 2024.11.17
//输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组中某一行的元素的平均值或元素的和。
//输入格式
//第一行输入整数 L ，表示所求的具体行数（行数从 0 开始计数）。
//第二行包含一个大写字母，若为 S，则表示需要求出第 L 行的元素的和，若为 M，则表示需要求出第 L 行的元素的平均值。
//接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i + 1 行的第 j + 1 个数表示数组元素 M[i][j]

//输入顺序是L、S、数组

//行数从 0 开始计数-- > 第1行记成第0行
//输入的数组第行数正常是从第1行记起的  //记第行数时可能会不统一，但角标数是固定统一

//#include<stdio.h>
//int main()
//{
//    int l, i, j;
//    char a;
//    double arr[12][12];
//    scanf("%d", &l);
//    scanf("%c", &a);
//    for (int i = 0;i < 12;i++)
//    {
//        for (int j = 0;j < 12;j++)
//        {
//            scanf("%lf", *(arr + i) + j);
//        }
//
//    }
//    double count = 0;
//    if (a == 'S')
//    {
//        for (j = 0;j < 12;j++)
//        {
//            count += arr[l][j];
//        }
//        printf("%.1lf", count);
//    }
//    else if (a == 'M')
//    {
//        for (j = 0;j < 12;j++)
//        {
//            count += arr[l][j];
//        }
//        printf("%.1lf", count / 12);
//    }
//    return 0;
//}

//int main()
//{
//    int l;
//    char a;
//    scanf("%d", &l);  // 读取一个整数  输入 7
//    scanf("%c", &a);  // 尝试读取一个字符（可能会出错） 输入 'S'
//    /*用户首先输入 7 作为整数，然后按下回车（这将产生一个换行符）。但是，在第二个 scanf（读取 char a 的时候）：
//    由于输入缓冲区中还有未读取的换行符（\n），scanf("%c", &a) 会立刻读取到这个换行符，所以 a 会被赋值为 '\n'，而不是用户想输入的字符 S。*/
//    //输入字符%c搜索字符时会把输入缓冲区的其它的%会跳过的而%c不跳过去读而读错(用户输入的回车'\n'、空格  )
//    printf("%d", l);
//    printf("%c", a);
//    return 0;
//}

//int main()
//{
//    int l;
//    char a;
//    scanf("%d", &l);
//    //getchar();//通常可以在读取字符之前添加一个 getchar()，以消耗掉上一个输入留下的换行符，getchar()只能跳过输入缓冲区的一个字符
//    scanf(" %c", &a);//也可以 %c，它会跳过所有的空格与\n直到截有
//    printf("%d\n", l);
//    printf("%c\n", a);
//    return 0;
//}

//条件表达式 op == 'S' ? s : s / 12 :
//这是一个 三元运算符，用于根据条件选择输出的值。结构为 condition ? value_if_true : value_if_false。
//op == 'S'：这是条件部分，检查变量 op 是否等于字符 'S'。
//s ：如果 op 是 'S'，则输出当前行所有元素的和。
//s / 12 ：如果 op 不是 'S'（我们假设可能是 'A' 或其他字符），则输出和的平均值，即将和 s 除以 12。

//#include<stdio.h>
//int main()
//{
//    int l;
//    char op;
//    scanf("%d %c", &l, &op); // 输入行索引 l 和操作符 op  
//    double s = 0.0;
//    for (int i = 0; i < 12; i++)
//    {
//        for (int j = 0; j < 12; j++)
//        {
//            double a;
//            scanf("%lf", &a); // 输入矩阵元素  
//            if (i == l)
//            {  //只要这一行的元素和，其它的不存起来不制出表都行
//                s += a; // 累加指定行的元素  
//            }
//        }
//    }
//    printf("%.1lf", op == 'S' ? s : s / 12);
//    return 0;
//}



//int main()
//{
//	int arr[3];// --> 3是数组元素总个数，等于数组最后第个数，比数组最后角标大1
//	return 0;
//}



//AC 745.数组的右上半部分 -- 2024.11.17
//输入的时候是把填满整个数组的数据都输入

//输入一个二维数组 M[12][12]，根据输入的要求，求出二维数组的右上半部分元素的平均值或元素的和。
//右上半部分是指主对角线上方的部分，如下图所示，黄色部分为对角线，绿色部分为右上半部分：
//输入格式
//第一行输入一个大写字母，若为 S，则表示需要求出右上半部分的元素的和，若为 M，则表示需要求出右上半部分的元素的平均值。
//接下来 12 行，每行包含 12 个用空格隔开的浮点数，表示这个二维数组，其中第 i + 1 行的第 j + 1 个数表示数组元素 M[i][j]。
//输出格式
//输出一个数，表示所求的平均数或元素的和的值，保留一位小数。
//输入样例：
//M
//- 6.5 8.2 0.7 9.0 0.8 - 4.3 0.9 - 0.0 - 7.9 7.1 - 1.6 4.6
//- 9.4 - 9.0 1.5 - 9.0 - 5.1 - 0.5 - 2.8 - 9.1 8.0 - 6.9 - 5.5 - 6.6
//- 6.8 0.3 3.8 6.1 - 9.9 - 9.3 8.5 8.6 5.0 6.9 - 3.6 - 3.0
//- 0.8 - 1.6 - 7.3 - 6.7 4.4 - 9.1 - 9.0 1.6 0.3 - 6.0 6.0 - 0.8
//- 0.8 - 6.0 - 4.9 - 3.9 6.4 6.2 - 4.2 - 0.9 7.9 1.6 - 8.2 - 9.2
//7.8 - 5.8 - 5.8 - 5.8 7.2 0.5 - 7.9 1.2 - 6.8 - 9.1 0.3 - 1.4
//4.3 - 7.2 3.5 - 6.4 - 9.1 - 6.0 3.5 - 5.1 - 5.6 - 6.9 - 9.1 - 2.1
//- 7.6 - 7.1 0.7 - 1.7 5.0 - 9.0 1.4 - 6.2 7.6 4.8 - 7.5 4.0
//- 0.2 0.3 - 4.2 8.4 0.7 - 6.4 - 2.7 3.5 - 0.9 3.7 0.9 - 2.7
//7.1 0.1 8.4 - 5.1 - 7.9 - 0.5 - 5.3 - 5.7 - 4.6 9.6 - 8.3 7.0
//9.6 - 9.8 3.3 - 9.9 - 6.8 6.7 3.1 1.2 - 9.5 - 4.3 - 1.7 - 9.7
//1.8 5.0 8.3 - 0.7 - 0.9 3.2 2.5 0.5 7.3 8.3 0.3 0.9

//#include<stdio.h>
//int main()
//{
//    char a;
//    scanf("%c", &a);
//    double arr[12][12], count = 0.0;
//    int b = 0;
//    for (int i = 0;i < 12;i++)
//    {
//        for (int j = 0;j < 12;j++)
//        {
//            scanf("%lf", &arr[i][j]);//全部都来接消掉缓冲区的那些没用的值，用scanf让它输消掉
//            if (i < j)
//            {
//                count += arr[i][j];
//                b++;
//            }
//        }
//    }
//    printf("%.1lf", a == 'S' ? count : count / b);
//    return 0;
//}



//逗号运算符(expr1, expr2, ..., exprN)按照从左到右的顺序计算每个表达式，并返回最后一个表达式的值,每个 expr 都会被执行，最终表达式的值是 exprN
//
//int main()
//{
//	int a = (1, 2, 3); // a 最终被赋值为 3 
//
//	int i;
//	int sum = 0;//逗号表达式至少要在()里，不是专属的也行
//	for (i = 1; i <= 5; sum += i, i++); // sum 最终是 15 
//
//	int x = 5, y = 10;
//	int result = (x += 2, y += 3, x * y); // result 最终是 7 * 13，即 91
//
//	int z;
//	int value = (z = 5, z + 3); // value 最终是 8
//	return 0;
//}



//做完再判断此次能否进入循环的模式与还是正常的第一次先做必做然后再正常的先判断再做do while 都能写成有，do while 只是结构这样，判断的在下面



//int main()
//{
//	int a;
//	scanf("%d", &a);
//	do
//		scanf("%d", &a);//与正常的写在上面的先执行代码不同，它是在循环体里
//	while (a);
//	return 0;
//}



//AC 753.平方矩阵I -- 2024.11.19

//#include<stdio.h>
//int min(int x, int y)
//{
//    return (x <= y ? x : y);
//}
//int main()
//{
//    int n;
//    while (scanf("%d", &n), n)//while(scanf("%d",&n == 1 && n>0)
//    {                                     //更正确下
//        for (int i = 0;i < n;i++)
//        {
//            for (int j = 0;j < n;j++)
//            {
//                printf("%d ", min(min(i + 1, j + 1), min(n - i, n - j)));
//            }
//            printf("\n");
//        }
//        printf("\n");
//    }
//        return 0;
//    
//}



//#include<stdio.h>
//void swap(int* x, int* y)
//{
//    int tmp = *x;
//    *x = *y;
//    *y = tmp;
//}
//int main()
//{
//    int i, a[20],j;
//    for (i = 0;i < 20;i++)
//        scanf("%d", a + i);
//
//    for (i = 0,  j = 19;i < j;i++, j--)
//    {    //都可以写多个
//        swap(a+i, a+j);
//    }
//    ////or
//    //int i = 0, j = 19;
//    //while (i < j)
//    //{
//    //    swap(a+i,a+j);
//    //    i++;
//    //    j--;
//    //}
//
//    for (i = 0;i < 20;i++)
//        printf("N[%d] = %d", i, a[i]);
//    return 0;
//}
//
//#include<stdio.h>
//int main()
//{
//    int a[20], i;
//    for (i = 0;i < 20;i++)
//    {
//        scanf("%d", a + i);
//    }
//    for (int j = 0;j < 20;j++)
//    {//i=20
//        i--;//执行完一次 --> 执行完第20次变0
//        printf("N[%d] = %d\n", j, a[i]);//变19
//    }
//    return 0;
//}



////强制放格式就转成取决于左边
//int main()
//{
//	int a[5] = { 1,2,3,4,5 };
//	int* p = &a;
//	printf("%d\n", *p);
//	double b = 3.14;
//	int d = b;
//	printf("%d\n", d);
//	return 0;
//}



//int main()
//{
//	int r, c, k = 1;//就k等于1
//	return 0;
//}



//AC 756.蛇形矩阵 -- 2024.11.24

//#include<stdio.h>
//#define N 110
//int main()
//{
//    int r, c, k = 1;
//    scanf("%d %d", &r, &c);
//    //1开始算的
//    int arr[N][N];//[]不能是变量，必须是常量值
//    int left = 0, right = c - 1, top = 0, bottom = r - 1;
//    while (left <= right && top <= bottom)
//    {
//        for (int i = left;i <= right && top<=bottom;i++)
//        {
//            //0开始算的
//            arr[top][i] = k++;
//        }
//        top++;
//        for (int i = top;i <= bottom && left<=right;i++)
//        {
//            arr[i][right] = k++;
//        }
//        right--;
//        for (int i = right;i >= left && top<=bottom;i--)
//        {
//            arr[bottom][i] = k++;
//        }
//        bottom--;
//        for (int i = bottom;i >= top && left<=right;i--)
//        {
//            arr[i][left] = k++;
//        }
//        left++;
//    }
//    for (int i = 0;i < r;i++)
//    {
//        for (int j = 0;j < c;j++)
//        {
//            printf("%d ", arr[i][j]);
//        }
//        printf("\n");
//    }
//    return 0;
//}



////输入的字符串有没有回车回车\n都是字符不需要额外去考虑它
//int main()
//{// \ 表示后面的数字是八进制的
// // \x 表示后面的数字是十六进制的
////是数字的转义字符且只能放在""里
//	//printf("%d\n",\66);//err
//	printf("\66");
//	return 0;
//}

//int main()
//      //字符比较、计算时与十进制转移字符互通的，十进制应该不算是字符的转移字符，字符与十进制数字互通互等的
//{//字符用数字(十进制、八进制、十六进制)表示，字符的转移字符(与位置联系)
//	//格式:   纯数字  '\数字'  '\x数字'
//	printf("57 = %c\n", 57);//字符用十进制数字表示 -- 纯数字57十进制57位置对过去是字符'9'
//	printf("%c\n", '\66');//字符用八进制数字表示 -- 八进制66位置对过去是字符'6'
//	printf("%d = '\x66' = %c\n", '\x66','\x66');//字符用十六进制数字表示 -- 十六进制66位置对的是字符'f'，同时是102十进制位置
//	 //""里转义字符直接转的,与\n一样的，'\x66'转成'f'
//	printf("%d\n", '57');//没有'多数字'的字符
//	//有'0~9'的单数字类字符
//	return 0;//%c搜索出字符时字符的''已省，%d搜索的是字符的十进制转移字符即十进制的位置
//}



//字符输入
//AC 760.字符串长度 -- 2024.11.25

//int main()
//{
//	char arr[4];//scanf输入时不读回车的，输入的字符输入完后会再补\0(放不下也强行放)
//	scanf("%s", arr);// = scanf("%s",&arr); //%s只要给它头地址都是往后找\0，地址头地址一样解引用权限不一样是无所谓的，只看头地址
//	printf("%s", arr);
//	return 0;
//}

//fgets 是 C 语言中用于从标准输入（通常是键盘）读取字符的库函数,头文件stdio.h
//库函数里的函数定义(部分):
//  char* fgets(char* str, int n, FILE* stream);
//str: 一个指向字符数组的指针，fgets 会把读取的字符存储在这个数组中。
//n : 要读取的最多字符数(包括了自己会加上的\0)
//stream : 指定输入流。常用的有 stdin （标准输入、通常是键盘输入）。

//#include<stdio.h>
//#include<string.h>
//int main()
//{
//    char str[101]; //要输的字符输入完后也会自己再补\0，一样一定会补\0，但是它是安全地补，放不下的就把输入的字符舍弃掉一些到刚好安全地放完
//    //最多放这么多，且放的最后一个一定是自己的\0，设置为字符数组长度，输入的结果就一定是安全的字符串
//    fgets(str, sizeof(str), stdin);//读回车的，回车读进就停止读
//    //读多少取决这里
//    printf("%s\n", str);//创建的字符数组是应付来放的，创建位置来放得下创大没事主要是暂时放得下就行
//    printf("%zd", strlen(str));
//    return 0;
//}

//AC 761.字符串中的数字个数 -- 2024.11.25
//输入一行字符，长度不超过 100，请你统计一下其中的数字字符的个数。
                   //只包括自己输入的，说字符、字符串它们都一样没考虑\0
//放字符字符串的数组的大小取决于输入的字符与输入函数会加的\0

//#include<stdio.h>
//int main()
//{
//    char arr[101];
//    int count = 0, i = 0;//%s对首来的空格会跳一次
//    //scanf("%s", arr);//%s搜索输入读到空格也会停下来，而fgets读取整行，包括空格
//    fgets(arr, sizeof(arr), stdin);
//    while (arr[i] > 0)//\0是0,空格是32，除了\0所有的字符都大于0
//        //遍历字符数组里放的字符串，遍历字符串到\0，\0不读
//    {
//        if (arr[i] >= '0' && arr[i] <= '9')
//        {
//            count++;
//            //i++;//err
//        }
//        i++;
//    }                      
//    printf("%d", count);
//    printf("%s\n", "abc d");
//    return 0;
//}



//int main()
//{        //分开  分开
//    if (1 == 1 && 3 && 0)
//        printf("hehe\n");
//    return 0;
//}



//int main()
//{
//    char arr[7], brr[7];
//    int a, b, n;
//    scanf("%d", &n);
//    while (n--)
//    {//%s会搜地址是，scanf要地址也是
//        scanf("%s%s", arr, brr);
//    //Hunter Gun 输入的空格刚好隔开%s输入进
//        a = strlen(arr);
//        b = strlen(brr);
//        if (a - b == 3 || a - b == -2 || a - b == -1)
//            printf("Player1\n");
//        else if (a - b == 0)
//            printf("Tie\n");
//        else
//            printf("Player2\n");
//    }
//    return 0;
//}



//int main()
//{
//    int i = 0;
//    char arr[101];
//    fgets(arr, sizeof(arr), stdin);
//    while (arr[i] > 0)
//    {
//        //自己创造专为打印层面
//        printf("%c ", arr[i]);
//        i++;
//    }
//    return 0;
//}



//#include<stdio.h>
//int main()
//{
//    int i = 0;
//    char arr[31], a;
//    scanf("%s", arr);
//    scanf(" %c", &a);//scanf里的%c不会跳空白的，会读回车的 ——> 空格%c(跳过所有的空格与换行符) 、getchar读取消耗掉输入缓冲区的一个的换行符(只能)
//    while (arr[i] > 0)
//    {
//        if (arr[i] == a)
//            arr[i] = '#';
//        i++;
//    }
//    printf("%s", arr);
//    return 0;
//}


//int main()
//{
//	char a = '   w';
//	printf(" %c", a);//printf里的空格%c没有效果
//	return 0;
//}



//AC 773.字符串插入 -- 2024.11.27

//输入:

//z a
//z烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫蘟烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫z烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫L
// --> z与\0交换后后面就没有\0了，一直越界往后找\0直到找到停下,也不会停下，'z'最大，在下一次i++后判断str[i]时一定交换值，此时的str[i]里装的一定还是'z'，'z'一直往外访问还访问到了substr内存里把'a'换走了继续换

//zz a
//z烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫蘟烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫z烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫L
//rZAHdP Sum
//ZAHdP烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫蘏rm烫烫烫烫烫烫烫烫烫烫烫烫烫烫u蘲m烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫蘈

//int main()
//{
//    char str[11], substr[4],change;
//    int max = 0, i = 0;
//    while (~scanf("%s%s", str, substr))
//    {
//        while (str[i] > 0)
//        {
//            if (str[i] > str[i + 1]) //如果要打印排序后的结果就要动数组，把数组里的值真排序再打印数组达到目的，所以两两进数组去遍历实现动数组
//                //i一次带两个，越来越大，一次带完会再带一次的在i+1
// 要全部排序的话要还要再来n-2，它这里一次只把最后一个排行最大
//            {
//                
//                change = str[i + 1];
//                //要交换因为后面还要打印
//                str[i + 1] = str[i];//跟随着带着最大的值
//                str[i] = change;
//                max = i;//没有跟随，单独来记大者原来位置的
//            }
//            else if (str[i] < str[i + 1])
//            {
//                max = i + 1;
//            }
//            i++;
//        }    //strlen也识地址
//        //打印的%s识地址位置往后搜
//        for (i = 0;i <= max;i++)
//        {
// //动数组动了\0在字符串里的位置
// //while (str[i] > 0)、for(i = 0;i < strlen(新);i++)、% s都错了
//            printf("%c", str[i]);
//        }
//        printf("%s", substr);
//
//        printf("%s", str + max + 1);
//        printf("\n");
//    }
//    return 0;
//}



//int main()
//{
//	for (int i = 0;i > 1;i++)
//	{  //循环初始化后的第一次也要判断
//		printf("hehe\n");
//	}
//	return 0;
//}



//没要求结束循环条件的循环就设置成输入直至输错自己输错停下的模式
//while (~scanf(" % d % d", &a, &b))是C语言的连续输入
//作用相同的还有while(scanf(" % d % d", &a, &b) != EOF)
//遍历字符串的除了\0的字符们，除了\0所有的字符都大于0（即\0）
//while (str[i] > 0)
//{
//
//	i++;
//}
//当然也可以for(int i = 0;i < strlen(str);i++)
//数组里找最大只要一个去遍历把当前最大值及时存起来比较更新，不需要赋数组动数组
//根本不需要动数组排序数组



//AC 773.字符串插入 -- 2024.11.27

//#include<stdio.h>
//int main()
//{
//    char str[11], substr[4];
//    //没要求结束循环条件的循环就设置成输入直至输错自己输错停下的模式
//    //while (~scanf(" % d % d", &a, &b))是C语言的连续输入
//    //作用相同的还有while(scanf(" % d % d", &a, &b) != EOF)
//    //strlen略掉输入时多加的\0准确地算出输入的字符个数
//    while (~scanf("%s%s", str, substr))
//    {
//        int max = 0;
//        int i = 1;
//        //遍历字符串的除了\0的字符们，除了\0所有的字符都大于0（即\0）
//        //while (str[i] > 0)
//        //{
//        //
//        //	i++;
//        //}
//        //当然也可以for(int i = 0;i < strlen(str);i++)
//        while (str[i] > 0)
//        {
//            //数组里找最大只要一个去遍历把当前最大值及时存起来比较更新，不需要赋数组动数组
//            //根本不需要动数组排序数组
//            if (str[i] > str[max])
//            {
//                max = i;
//            }
//            i++;
//        }
//        for (i = 0;i <= max;i++)
//        {
//            printf("%c", str[i]);
//        }
//        printf("%s", substr);
//        //or
//        //i = 0;
//        //while(substr[i]>0)
//        //{
//        //printf("%c", substr[i]);
//        //i++
//        //}
//        printf("%s", str + max + 1);
//        //or
//        //max++;
//        //while (str[max] > 0)
//        //{
//        //    printf("%c", str[max]);
//        //    max++;
//        //}
//        printf("\n");
//    }
//    return 0;
//}



//AC 772.只出现一次的字符

//#include<stdio.h>
//int main()
//{
//    char arr[100001];
//    int x[256];
//    //int ×[256]= {0}：定义一个整型数组，用于存储每个字符的出现次数。数组大小为256，因为ASCI字符集的大小为256。
//    //arr[数字索引]这里取的索引不连续但也独一无二任何一种字符能分别有变量对应
//    scanf("%s", arr);
//    int i = 0;
//    while (arr[i] > 0)
//    {
//        x[arr[i]]++;
//        i++;
//    }
//    i = 0;
//    while (arr[i] > 0)
//    {
//        if (x[arr[i]] == 1)
//        {
//            printf("%c", arr[i]);
//            return 0;
//        }
//        i++;
//    }
//    printf("no");
//    return 0;
//}



//AC 762.字符串匹配 -- 2024.11.28

//#include<stdio.h>
//int main()
//{
//    double k;
//    int i = 0;
//    double count = 0;
//    scanf("%lf", &k);
//    char arr[101], brr[101];
//    scanf("%s%s", arr, brr);
//    while (arr[i] > 0)
//    {
//        if (arr[i] == brr[i])
//            count++;
//        i++;
//    }//字符串长度不包括'\0'
//    if (count / (strlen(arr)) >= k)
//        printf("yes");
//    else
//        printf("no");
//    return 0;
//}



//输入:
//c  IcMV jXKY Myb DSsH ND iT  Lh uCJurPRwVF  WImuItyvmIYjuXxHIfQz DOT   vE  v DeA  ——80个字符,回车进了输入缓冲区
//c  IcMV jXKY Myb ND iT  Lh uCJurPRwVF  WImuItyvmIYjuXxHIfQz DOT   vE  v DeA
//输出:
//>
//标准答案:
//<
//brr收到的是\n回车
//字符串长度不包括'\0'、用户的回车。回车也是当作输入的字符放，scanf(%s)的输入不管数组空间放得下放不下，放得下当前输入的字符，输入完后直接强行加\0，回车是没机会放进它数组，一定进输入缓冲区；scanf(%c)输入完后一定有回车在输入缓冲区；fgets的如果数组放得下回车就输入进数组里了然后再补上fgets的\0，但如果放不下\0肯定比\n更重要，其它输入的字符以及\n都很可能舍弃，进输入缓冲区。缓冲区留有\n，要看输入格式会不会自己滤掉回车，像scanf里的%s会跳开头的空格回车,结尾以空格回车停达到截效果,它会跳过回车，但scanf里的%c和fgets不会跳空格回车

//#include<stdio.h>
//#include<string.h>
//int main()
//{
//    int c, i = 0;
//    //char arr[81], brr[81]; --> 再调大一点回车定放下，输入缓冲区就定没有\n了,就不需要getchar来解决可能的输入缓冲区有剩
//    char arr[82], brr[82];
//    fgets(arr, sizeof(arr), stdin);
//    //getchar();//err --> 如果输入没多它这里强行要一个字符取了比较对象的一个字符
//    fgets(brr, sizeof(brr), stdin);
//    int a = strlen(arr);
//    int b = strlen(brr);
//    if (a > b)
//    {
//        c = b;
//    }
//    else
//    {
//        c = a;
//    }
//    for (i = 0;i < c;i++)
//    {
//        if (arr[i] < brr[i] && (brr[i] - arr[i] != 32 || brr[i] < 'a' || brr[i]>'z'))
//        {
//            printf("<");
//            return 0;
//        }
//        else if (arr[i] > brr[i] && (arr[i] - brr[i] != 32 || arr[i] < 'a' || arr[i]>'z'))
//        {
//            printf(">");
//            return 0;
//        }
//    }
//    if (a > b)
//        printf(">");
//    else if (a < b)
//        printf("<");
//    else
//        printf("=");
//    return 0;
//}

//#include<stdio.h>
//#include<string.h>
//int main()
//{
//    int c, i = 0;
//    char arr[82], brr[82];
//    fgets(arr, sizeof(arr), stdin);
//    //getchar();
//    fgets(brr, sizeof(brr), stdin);
//    int a = strlen(arr);
//    int b = strlen(brr);
//    if (a > b)
//    {
//        c = b;
//    }
//    else
//    {
//        c = a;
//    }
//    for (i = 0;i < c;i++)
//    {
//        if (arr[i] >= 65 && arr[i] <= 90)
//            arr[i] += 32;
//        if (brr[i] >= 65 && brr[i] <= 90)
//            brr[i] += 32;
//        if (arr[i] > brr[i])
//        {
//            printf(">");
//            return 0;
//        }
//        else if (arr[i] < brr[i])
//        {
//            printf("<");
//            return 0;
//        }
//    }
//    if (a > b)
//        printf(">");
//    else if (a < b)
//        printf("<");
//    else
//        printf("=");
//    return 0;
//}



   //函数定义这边有形参等接调用时就必须全传上
//int add(int x, int y);
//int main()
//{
//	//add();//err
//	return 0;
//}

         //它的形参列表为空，表示它不接受任何参数
//int getchar(void)
//返回值是一个int类型，表示读取到的字符的ASCII值
//{
//
//}

//text()
//{
//
//}
//int main()
//{
//	getchar();//它与其它无传参函数不一样，它挡着要传一个从标准输入流传一个才让过
//	//无参数调用：getchar函数不需要任何外部参数来执行其功能，它直接从标准输入流读取一个字符
//	text();
//	return 0;
//}



//AC 764.输出字符串 -- 2024.11.29

//输入 /''#376-5!
//输出 VNJVjmcbV+9.
//标准答案 VNJVjmcbVP

//#include<stdio.h>
//int main()
//{
//    int i = 0;
//    char arr[101];
//    fgets(arr, sizeof(arr), stdin);
//    //fgets输入如果有多加回车去掉它多加的回车
//    int a = strlen(arr);
//    if (arr[a - 1] == '\n')
//        arr[a - 1] = '\0';
//    while (arr[i] > 0)
//    {                         //or
//        if (arr[i + 1] == 0 || arr[i + 1] == '\n')
//        {
//            //arr[i + 1] = arr[0];//err
//            //本来停下就以arr[i + 1]的\0停下，你把里面装的\0改成非0了
//            printf("%c", arr[i] + arr[0]);
//            return 0;
//        }
//        printf("%c", arr[i] + arr[i + 1]);
//        i++;
//    }
//    return 0;
//}